home *** CD-ROM | disk | FTP | other *** search
/ Software 2000 / Software 2000 Volume 1 (Disc 1 of 2).iso / utilities / u289.dms / in.adf / Kpri / src.lzh / process.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-02  |  11.5 KB  |  495 lines
  1. #include "defs.h"
  2.  
  3. Prototype __regargs void  split_bufs(PE *, PE *);
  4. Prototype           SHORT do_process(void);
  5. Prototype __regargs SHORT read_file(PE *);
  6. Prototype __regargs SHORT alloc_buf(PE *);
  7. Prototype           PE   *do_open(void);
  8. Prototype __regargs PE   *double_pe(PE *);
  9. Prototype           PE   *init_pe(void);
  10. Prototype __regargs void  count_pages(PE *);
  11. Prototype __regargs void  do_name(PE *, UBYTE *);
  12. Prototype           void  get_date(void);
  13. Prototype __regargs void  ask_print(UBYTE *);
  14.  
  15. Prototype const UBYTE resume[];
  16. Prototype UBYTE date_buf[30];
  17.  
  18. UBYTE date_buf[30];
  19.  
  20.  
  21. /***********************  double_pe(void) ****************************/
  22. __regargs PE    *
  23. double_pe(PE * old)
  24. {
  25.   PE    *pe;
  26.  
  27.   if (pe = init_pe())
  28.   {
  29.     strcpy(pe->FullName, old->FullName);
  30.     strcpy(pe->pe_node.ln_Name, old->pe_node.ln_Name);
  31.     pe->Size        = old->Size;
  32.     pe->pagesize    = old->pagesize;
  33.     pe->linelength  = old->linelength;
  34.     return (pe);
  35.   }
  36.   return (NULL);
  37. }
  38.  
  39. /***********************  read_file()  **************************/
  40. const UBYTE readerror[] = "***Error: Reading %s failed !";
  41. const UBYTE resume[]    = "resume";
  42. __regargs SHORT
  43. read_file(PE * pe)
  44. {                                       /* read file into buffer  */
  45.   SHORT  done = FALSE;
  46.  
  47.   if (pe->Size == Read(pe->Handle, pe->SplitBuffer, pe->Size))
  48.     done = TRUE;
  49.   else
  50.     do_request(readerror, resume, pe->FullName);
  51.  
  52.   Close(pe->Handle);
  53.   return (done);
  54. }
  55.  
  56. /***********************  do_open(void) ******************************/
  57. const UBYTE openerror[] = "***Error: Opening %s failed !";
  58.  
  59. PE *
  60. do_open(void)
  61. {
  62.   PE    *pe    = NULL;
  63.   SHORT  memok = FALSE;
  64.   SHORT  open  = FALSE;
  65.   FIB   *fib_ptr;
  66.  
  67.   if (fib_ptr = (FIB *) AllocMem(sizeof(FIB), MPC))
  68.   {
  69.     memok = TRUE;
  70.     FL    *lock;
  71.  
  72.     if (lock = (FL *) Lock(Buf_storage_str, SHARED_LOCK))
  73.     {
  74.       if (Examine(lock, fib_ptr))
  75.       {
  76.         if (pe = init_pe())
  77.         {
  78.           if (pe->Handle = (FH *) Open(Buf_storage_str, MODE_OLDFILE))
  79.           {
  80.             pe->Size = fib_ptr->fib_Size;
  81.  
  82.             UBYTE  *d = pe->pe_node.ln_Name;
  83.             UBYTE  *s = fib_ptr->fib_FileName;
  84.  
  85.             for (; *d = *s; ++s, ++d) ;
  86.  
  87.             for (d = pe->FullName, s = Buf_storage_str;
  88.                  *d = *s; ++s, ++d) ;
  89.  
  90.             open = TRUE;
  91.           }
  92.           else
  93.             FreeRem(pe->memory);
  94.         }
  95.         else
  96.           memok = FALSE;
  97.       }
  98.       UnLock(lock);
  99.     }
  100.     FreeMem(fib_ptr, sizeof(FIB));
  101.   }
  102.  
  103.   if (!memok)
  104.     quit = autom = TRUE;
  105.  
  106.   if (!open)
  107.     do_request(openerror, resume, Buf_storage_str);
  108.  
  109.   return (pe);
  110. }
  111.  
  112. /***********************  init_pe(void) ******************************/
  113. PE  *
  114. init_pe(void)
  115. {
  116.   LONG  *pet;
  117.  
  118.   if (pet = (LONG *) AllocMem(sizeof(PE) + 8, MPC))
  119.   {
  120.     pet[1] = sizeof(PE) + 8;
  121.     PE *pe = (PE *) (pet + 2);
  122.     pe->memory = pet;
  123.  
  124.     if (pe->pe_node.ln_Name = (UBYTE *) AllocRem(pe, MAXPATH))
  125.     {
  126.       if (pe->FullName = (UBYTE *) AllocRem(pe, MAXPATH))
  127.       {
  128.         pe->pagesize   = pagesize;
  129.         pe->linelength = linelength;
  130.         return (pe);
  131.       }
  132.       FreeRem(pe->memory);
  133.     }
  134.     FreeMem(pe, sizeof(PE) + 8);
  135.   }
  136.   return (NULL);
  137. }
  138.  
  139.  
  140. /***********************  alloc_buf()  **************************/
  141. __regargs SHORT
  142. alloc_buf(PE * pe)                      /* each buffer needs size of file   */
  143. {
  144.   int    bsize = max(pe->Size, MIN_BUF_SIZE);
  145.  
  146.   if ((bsize << 1) < AvailMem(MEMF_PUBLIC))
  147.   {
  148.     if ((pe->SplitBuffer = (UBYTE *) AllocRem(pe, bsize)) != 0)
  149.       return (TRUE);
  150.   }
  151.   return (FALSE);
  152. }
  153.  
  154. /***********************  do_process()  **************************/
  155. SHORT
  156. do_process(void)
  157. {
  158.   PE    *prieve;
  159.  
  160.   if (prieve = do_open())
  161.   {
  162.     if (alloc_buf(prieve))
  163.     {
  164.       if (read_file(prieve))
  165.       {
  166.         if (split || title)
  167.         {
  168.           PE    *priodd;
  169.  
  170.           if (priodd = double_pe(prieve))
  171.           {
  172.             if (!split)               /*  add space for titling */
  173.               priodd->Size <<= 1;
  174.  
  175.             if (alloc_buf(priodd))
  176.             {
  177.               split_bufs(prieve, priodd);
  178.  
  179.               if (prieve->Size && priodd->Size)
  180.               {
  181.                 priodd->pe_node.ln_Type = ODD;
  182.                 do_name(priodd, "ODD ");
  183.                 prieve->pe_node.ln_Type = EVEN;
  184.                 do_name(prieve, "EVEN");
  185.               }
  186.               else
  187.               {
  188.                 if (priodd->Size)
  189.                 {
  190.                   priodd->pe_node.ln_Type = ALL;
  191.                   do_name(priodd, "TITL");
  192.                   FreeRem(prieve->memory);
  193.                 }
  194.               }
  195.               return (TRUE);
  196.             }
  197.           }
  198.         }
  199.         else
  200.         {
  201.           prieve->pe_node.ln_Type = ALL;
  202.           count_pages(prieve);
  203.           do_name(prieve, "ALL ");
  204.         }
  205.       }
  206.     }
  207.   }
  208.   return (FALSE);
  209. }
  210.  
  211. /***********************  do_name  ********************************/
  212. __regargs void
  213. do_name(PE *pe, UBYTE *page)
  214. {
  215.   UBYTE  *buf;
  216.  
  217.   if (buf = (UBYTE *) AllocMem(MAXPATH, MPC))
  218.   {
  219.     UBYTE *d = buf;
  220.     UBYTE *s = pe->pe_node.ln_Name;
  221.     SHORT  i = 0;
  222.  
  223.     for (; *d = *s; ++s, ++d, ++i);
  224.  
  225.     for (; i < 15; *d++ = ' ', ++i);
  226.  
  227.     sprintf(d, "<%s %2dpg>", page, pe->pagenum);
  228.  
  229.     strcpy(pe->pe_node.ln_Name, buf);
  230.  
  231.     pe->pe_node.ln_Pri = 4 - pe->pe_node.ln_Type;
  232.  
  233.     update_list(pe);
  234.  
  235.     if (autom)
  236.       ask_print(buf);
  237.  
  238.     FreeMem(buf, MAXPATH);
  239.   }
  240.   else
  241.     quit = autom = TRUE;
  242. }
  243.  
  244.  
  245. /***********************  ask_print() ******************************/
  246. const UBYTE printnow0[] = "Print %s now ???";
  247. const UBYTE printnow1[] = "Yes, print it|No, skip it";
  248.  
  249. __regargs void
  250. ask_print(UBYTE *name)
  251. {
  252.   if (do_request(printnow0, printnow1, name))
  253.   {
  254.     if (name != Buf_storage_str)
  255.       strcpy(Buf_storage_str, name);
  256.     do_print_it();
  257.   }
  258. }
  259.  
  260. /***********************  count_pages ****************************/
  261. const SHORT psize[2] = { 66, 88 };
  262.  
  263. __regargs void
  264. count_pages(PE *pe)
  265. {
  266.   SHORT maxline = psize[pagesize];
  267.   LONG  chars   = 1;
  268.   UBYTE *ptr    = pe->SplitBuffer;
  269.  
  270.   while (chars < pe->Size)
  271.   {
  272.     SHORT lines = 0;
  273.     ++pe->pagenum;
  274.     while (lines++ < maxline)
  275.       while ((*ptr++ != '\n') && (chars++ < pe->Size));
  276.   }
  277. }
  278.  
  279. /***********************  split_bufs()  **************************/
  280. const UBYTE pagestr[] = "Page %3d";
  281. const UBYTE normal[]  = "\x9B0m\n\n\n";
  282. const UBYTE dobold[]  = "\n\x9B1m";
  283. const SHORT mchars[]  = { 80, 80, 96 };
  284.  
  285. __regargs void
  286. split_bufs(PE * prieve, PE * priodd)    /* does titling here if ordered  */
  287. {
  288.   SHORT maxchars = mchars[linelength];
  289.   SHORT maxline  = psize[pagesize];
  290.  
  291.   UBYTE *ptr[2];
  292.   ptr[ODD]       = priodd->SplitBuffer;
  293.   ptr[EVEN]      = prieve->SplitBuffer;
  294.   UBYTE *filptr  = prieve->SplitBuffer;
  295.  
  296.   int    pagenum = 1;                   /* start positions */
  297.   SHORT  side    = ODD;
  298.  
  299.   if (title)
  300.   {
  301.     UBYTE *fname_ptr = ptr[ODD] + ((maxchars -
  302.                             strlen(prieve->pe_node.ln_Name)) >> 1);
  303.  
  304.     UBYTE *end_ptr   = ptr[ODD] + maxchars - 8;
  305.  
  306.     ptr[ODD] = (UBYTE *) stpcpy(ptr[ODD], dobold);
  307.     ptr[ODD] = (UBYTE *) stpcpy(ptr[ODD], date_buf);
  308.  
  309.     for (; ptr[ODD] < fname_ptr; *ptr[ODD]++ = ' ');
  310.  
  311.     ptr[ODD] = (UBYTE *) stpcpy(ptr[ODD], prieve->pe_node.ln_Name);
  312.  
  313.     for (; ptr[ODD] < end_ptr;   *ptr[ODD]++ = ' ');
  314.  
  315.     ptr[ODD] += sprintf(ptr[ODD], pagestr, pagenum);
  316.  
  317.     ptr[ODD] = (UBYTE *) stpcpy(ptr[ODD], normal);
  318.  
  319.     maxline -= 4;
  320.   }
  321.  
  322.   SHORT  linenum = 1;                   /* start positions */
  323.   SHORT  charnum = 0;
  324.  
  325.   while (*filptr)                       /* counter */
  326.   {
  327.     *ptr[side]++ = *filptr;             /* UBYTE copy */
  328.  
  329.     if (*filptr == '\n')                /* end of line */
  330.     {
  331.       ++linenum;
  332.       if (linenum > maxline)           /* end of page */
  333.       {
  334.         ++pagenum;
  335.  
  336.         if (split)                      /* both sides ordered ?  */
  337.           toggle(side);
  338.  
  339.         if (title)
  340.         {
  341.           UBYTE *fname_ptr = ptr[side] + ((maxchars -
  342.                                    strlen(prieve->pe_node.ln_Name)) >> 1);
  343.  
  344.           UBYTE *end_ptr   = ptr[side] +   maxchars;
  345.  
  346.           ptr[side] = (UBYTE *) stpcpy(ptr[side], dobold);
  347.  
  348.           if (!side)                    /* ODD:  date,   filename, pageno */
  349.           {
  350.             ptr[ODD] = (UBYTE *) stpcpy(ptr[ODD], date_buf);
  351.             end_ptr -= 8;               /* len of "Page ###"  */
  352.           }
  353.           else                          /* EVEN: pageno, filename, date  */
  354.           {
  355.             ptr[EVEN] += sprintf(ptr[EVEN], pagestr, pagenum);
  356.             end_ptr   -= strlen(date_buf);
  357.           }
  358.  
  359.           for (; ptr[side] < fname_ptr; *ptr[side]++ = ' ');
  360.  
  361.           ptr[side] = (UBYTE *) stpcpy(ptr[side], prieve->pe_node.ln_Name);
  362.  
  363.           for (; ptr[side] < end_ptr;   *ptr[side]++ = ' ');
  364.  
  365.           if (!side)
  366.             ptr[ODD] += sprintf(ptr[ODD], pagestr, pagenum);
  367.           else
  368.             ptr[EVEN] = (UBYTE *) stpcpy(ptr[EVEN], date_buf);
  369.  
  370.           ptr[side] = (UBYTE *) stpcpy(ptr[side], normal);
  371.         }
  372.         linenum = 1;                    /* new page  */
  373.       }
  374.       charnum = 0;                      /* checks for line too long  */
  375.     }
  376.     if (++charnum > maxchars)           /* input line too long   */
  377.     {
  378.       *filptr = '\n';                   /* split line  */
  379.       continue;                         /* go copy it into buffer  */
  380.     }
  381.     ++filptr;
  382.   }                                     /*  all copied  */
  383.   if (linenum > 1)
  384.     *ptr[side]++ = '\f';                /* do formfeed */
  385.  
  386.   if (!side && split)                   /* make even pagenumber anyway */
  387.   {
  388.     *ptr[EVEN]++ = '\f';
  389.     ++pagenum;
  390.   }
  391.   prieve->Size = ptr[EVEN] - prieve->SplitBuffer;
  392.   priodd->Size = ptr[ODD]  - priodd->SplitBuffer;
  393.   prieve->pagenum = priodd->pagenum = pagenum;
  394. }
  395.  
  396.  
  397. /***********************  get_date()  **************************/
  398. const UBYTE *mname[13] = { 0,
  399.                         "Jan.", "Febr.", "Mar.", "Apr.",
  400.                         "May",  "June",  "July", "Aug.",
  401.                         "Sept.","Oct.",  "Nov.", "Dec." };
  402.  
  403. const UBYTE *dname[8]  = { 0,
  404.                         "Sunday",   "Monday",   "Tuesday",  "Wednesday",
  405.                         "Thursday", "Friday",   "Saturday" };
  406. const UBYTE *dayext[4] = {
  407.                         "th", "st", "nd", "rd" };
  408.  
  409. void
  410. get_date()
  411. {
  412.   DATE  *datestamp;
  413.  
  414.   if (datestamp = (DATE *) AllocMem(sizeof(DATE), MPC))
  415.   {
  416.     DateStamp(datestamp);
  417.     ULONG  allday = datestamp->ds_Days;
  418.  
  419.     FreeMem(datestamp, sizeof(DATE));
  420.  
  421.     UWORD  year   = 1978;
  422.     UBYTE  month  =  1;
  423.     UBYTE  day    =  1;
  424.     UBYTE  today  =  1;
  425.     UBYTE  maxday = 31;
  426.  
  427.     while (allday--)
  428.     {
  429.       if (day++ == maxday)              /* next month  */
  430.       {
  431.         switch (++month)
  432.         {
  433.         case 2:
  434.           if (year % 4)                 /* no leap-year ?  */
  435.             maxday = 28;
  436.           else
  437.             maxday = 29;
  438.           break;
  439.  
  440.         case 13:                        /* happy new year  */
  441.           ++year;
  442.           month = 1;
  443.  
  444.         case 3:
  445.         case 5:
  446.         case 7:
  447.         case 8:
  448.         case 10:
  449.         case 12:
  450.           maxday = 31;
  451.           break;
  452.  
  453.         default:
  454.           maxday = 30;
  455.           break;
  456.         }
  457.         day = 1;
  458.       }
  459.  
  460.       if (++today == 8)                 /* next week */
  461.         today = 1;
  462.     }
  463.  
  464.     int i;
  465.  
  466.     switch (day)
  467.     {
  468.     case  1:
  469.     case 21:
  470.     case 31:
  471.       i = 1;
  472.       break;
  473.     case  2:
  474.     case 22:
  475.       i = 2;
  476.       break;
  477.     case  3:
  478.     case 23:
  479.       i = 3;
  480.       break;
  481.     default:
  482.       i = 0;
  483.       break;
  484.     }
  485.     sprintf(date_buf, "%s, %d%s %s %d",
  486.             dname[today], day, dayext[i], mname[month], year);
  487.   }
  488.   else
  489.   {
  490.     quit  = TRUE;
  491.     autom = TRUE;
  492.   }
  493. }
  494.  
  495.